package com.suixuan.support.util;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.regex.Pattern;

import org.apache.james.security.DigestUtil;
import org.springframework.security.authentication.encoding.Md5PasswordEncoder;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * @author Administrator
 */
public final class SecurityUtils {

	/**
	 * MD5加密实例
	 */
	private static final Md5PasswordEncoder MD5_INSTANCE = new Md5PasswordEncoder();
	/**
	 * Base64加密实例
	 */
	private static final BASE64Encoder BASE64_ENCODER_INSTANCE = new BASE64Encoder();
	/**
	 * Base64解密实例
	 */
	private static final BASE64Decoder BASE64_DECODER_INSTANCE = new BASE64Decoder();

	/**
	 * 将字符串数组转换为集合，并去除空格
	 * 
	 * @param arrays
	 *            字符串数组
	 * @return 集合
	 */
	public static Collection<String> arrayToCollection(String[] arrays) {
		Collection<String> coll = new ArrayList<String>();
		for (String arr : arrays) {
			coll.add(arr.trim());
		}
		return coll;
	}

	/**
	 * 判断当前字符串是否为数字
	 * 
	 * @param value
	 *            判断的字符串
	 * @return 当前字符是数字返回True
	 */
	public static boolean matchNumber(String value) {
		return Pattern.compile("[0-9]*(\\.?)[0-9]*").matcher(value).matches();
	}

	/**
	 * MD5加密
	 * 
	 * @param value
	 *            需加密的值
	 * @param key
	 *            种子值
	 * @return MD5加密后的值
	 */
	public static String md5PasswordEncoder(String value, String key) {
		return MD5_INSTANCE.encodePassword(value, key);
	}

	/**
	 * MD5加密
	 * 
	 * @param value
	 *            需加密的值
	 * @return MD5加密后的值
	 */
	public static String md5PasswordEncoder(String value) {
		return md5PasswordEncoder(value, null);
	}

	/**
	 * SHA加密
	 * 
	 * @param value
	 *            需加密的值
	 * @return SHA加密后的值
	 * @throws NoSuchAlgorithmException
	 */
	public static String shaPasswordEncoder(String value) throws NoSuchAlgorithmException {
		return DigestUtil.digestString(value, ConstantUtils.SHA);
	}

	/**
	 * Base64加密
	 * 
	 * @param value
	 *            需加密的字符串
	 * @return Base64加密后的字符串
	 */
	public static String base64Encoder(String value) {
		byte[] b = null;
		// 默认按照UTF-8编码，如果平台不支持，使用平台默认编码方式
		try {
			b = value.getBytes(ConstantUtils.ENCODER_UTF_8);
		} catch (UnsupportedEncodingException e) {
			b = value.getBytes();
		}
		return BASE64_ENCODER_INSTANCE.encode(b);
	}

	/**
	 * Base64解密
	 * 
	 * @param value
	 *            需解密的字符串
	 * @return Base64解密后的字符串
	 * @throws IOException
	 *             抛出异常
	 */
	public static String base64Decoder(String value) throws IOException {
		String s = null;
		// 默认按照UTF-8编码，如果平台不支持，使用平台默认编码方式
		try {
			s = new String(BASE64_DECODER_INSTANCE.decodeBuffer(value), ConstantUtils.ENCODER_UTF_8);
		} catch (UnsupportedEncodingException e) {
			s = new String(BASE64_DECODER_INSTANCE.decodeBuffer(value));
		} catch (IOException e) {
			s = new String(BASE64_DECODER_INSTANCE.decodeBuffer(value));
		}
		return s;
	}

	public static void main(String[] args) throws Exception {
		String s = base64Encoder("12345<>中国'\\h");
		System.out.println(base64Decoder(s));
	}

	private SecurityUtils() {
	}

}
